home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 December / PCWorld_2005-12_cd.bin / software / temacd / tiny / tpf-6[1].5.126.exe / Tiny Firewall 2005.msi / webui.dll / IDS / IDS-SDBFNCS.JS < prev    next >
Encoding:
JavaScript  |  2005-08-17  |  33.2 KB  |  1,130 lines
  1. /*//////////////////////////////////////////////////////////////////////
  2. Filename:          ids-sdbfncs.js
  3. Company Name:      Computer Associates International, Inc.
  4. Legal Copyright: Copyright (c) Computer Associates International, Inc.
  5. Author:          Ales Novak
  6. Product:          Tiny Firewall
  7. Description:      javascript code to access active IDS db through XMLSecDBParser COM iface
  8. ///////////////////////////////////////////////////////////////////////*/
  9.  
  10. // requires sdb-consts.js + sdb-msgs.js + tools.js
  11.  
  12. ///////////////////////////////////////////////////////////////////////
  13. // getRuleGroupList - internal function
  14. function IDS_getRuleGroupList()
  15. {
  16.     return external.ServerParser(XM_IDS).GroupList;
  17. }
  18.  
  19. ///////////////////////////////////////////////////////////////////////
  20. // getDefinitionList - internal function
  21. function IDS_getDefinitionList()
  22. {
  23.     return external.ServerParser(XM_IDS).DefinitionList;
  24. }
  25.  
  26. ///////////////////////////////////////////////////////////////////////
  27. // saveChanges - internal function
  28. function IDS_saveChanges( bAvoidSavingSDB )
  29. {
  30.     if (!bAvoidSavingSDB || !parseBoolean(bAvoidSavingSDB))
  31.     {
  32.         var parser = external.ServerParser(XM_IDS);
  33.         parser.Save(parser.FilePath);
  34.         //external.Save();
  35.     }
  36. }
  37.  
  38. ///////////////////////////////////////////////////////////////////////
  39. // generateSID - internal function
  40. function IDS_generateSID()
  41. {
  42.     return external.ServerParser(XM_IDS).GenerateSID();
  43. }
  44.  
  45. ///////////////////////////////////////////////////////////////////////
  46. // getRuleByRuleID - internal function
  47. //
  48. function getRuleByRuleID( strRuleGroup, iRuleID )
  49. {
  50.     try {
  51.         var group = IDS_getRuleGroupList().Get(strRuleGroup);
  52.  
  53.         var itemEnum = new Enumerator(group.RuleList);
  54.         itemEnum.moveFirst();
  55.  
  56.         while (!itemEnum.atEnd())
  57.         {
  58.             var rule = itemEnum.item();
  59.             if (rule.SID == parseInt(iRuleID))
  60.             {
  61.                 return rule;
  62.             }
  63.             itemEnum.moveNext();
  64.         }
  65.         return null;
  66.     } catch(e){
  67.         ErrorHandler( ERR_IDS_RULE_DOES_NOT_EXIST, STR_IDS_RULE_DOES_NOT_EXIST );
  68.         return null;
  69.     }
  70. }
  71.  
  72. ///////////////////////////////////////////////////////////////////////
  73. // IDS_AddRuleGroup - returns error if group already exists
  74. //
  75. function IDS_AddRuleGroup( strRuleGroup, bAvoidSavingSDB )
  76. {
  77.     try {
  78.         var groupList = IDS_getRuleGroupList();
  79.         var group = groupList.CreateGroup();
  80.         group.Name = strRuleGroup;
  81.         groupList.Insert( group );
  82.         IDS_saveChanges( bAvoidSavingSDB );
  83.         return SUCCESS;
  84.     } catch(e){
  85.         return ErrorHandler( ERR_IDS_ADDING_GROUP_FAILED, STR_IDS_ADDING_GROUP_FAILED );
  86.     }
  87. }
  88.  
  89. ///////////////////////////////////////////////////////////////////////
  90. // IDS_DeleteRuleGroup - deletes also all rules in the group
  91. //
  92. function IDS_DeleteRuleGroup( strRuleGroup, bAvoidSavingSDB )
  93. {
  94.     try {
  95.         var groupList = IDS_getRuleGroupList();
  96.         var group = groupList.Get(strRuleGroup);
  97.         groupList.Remove( group );
  98.         IDS_saveChanges( bAvoidSavingSDB );
  99.         return SUCCESS;
  100.     } catch(e){
  101.         return ErrorHandler( ERR_IDS_DELETE_GROUP_FAILED, STR_IDS_DELETE_GROUP_FAILED );
  102.     }
  103. }
  104.  
  105. ///////////////////////////////////////////////////////////////////////
  106. // IDS_GetTokenIDFromXMLAttributeValue - gets value such as "byte_test" and returns TID_BYTE_TEST or -1 on error
  107. //
  108. function IDS_GetTokenIDFromXMLAttributeValue( strTokenIdAttr )
  109. {
  110.     switch (strTokenIdAttr) {
  111.         case "dsize": return TID_DSIZE;
  112.         case "pcre": return TID_PCRE;
  113.         case "content": return TID_CONTENT;
  114.         case "byte_test": return TID_BYTE_TEST;
  115.         case "byte_jump": return TID_BYTE_JUMP;
  116.         case "isdataat": return TID_IS_DATA_AT;
  117.         case "sameadr": return TID_SAMEADR;
  118.         case "ip_ttl": return TID_IP_TTL;
  119.         case "ip_tos": return TID_IP_TOS;
  120.         case "ip_id": return TID_IP_ID;
  121.         case "ip_opt": return TID_IP_OPT;
  122.         case "ip_frg": return TID_IP_FRG;
  123.         case "ip_ptc": return TID_IP_PTC;
  124.         case "tcp_flg": return TID_TCP_FLG;
  125.         case "tcp_seq": return TID_TCP_SEQ;
  126.         case "tcp_ack": return TID_TCP_ACK;
  127.         case "icmp_type": return TID_ICMP_TYPE;
  128.         case "icmp_code": return TID_ICMP_CODE;
  129.         case "echo_id": return TID_ECHO_ID;
  130.         case "echo_seq": return TID_ECHO_SEQ;
  131.         case "tcp_window": return TID_TCP_WINDOW;
  132.         case "flow": return TID_FLOW;
  133.         case "flowbits": return TID_FLOW_BITS;
  134.         case "asn1": return TID_ASN1;    // this token id is unsure...
  135.     }
  136.     return (-1);
  137.   }
  138.  
  139.  
  140.  
  141. ///////////////////////////////////////////////////////////////////////
  142. // IDS_GetTokenValueTypeByTokenID
  143. //
  144. function IDS_GetTokenValueTypeByTokenID( eTokenID )
  145. {
  146.     switch (parseInt(eTokenID)) {
  147.         case TID_PCRE: return TT_STR;
  148.         case TID_CONTENT: return TT_STR;
  149.         case TID_FLOW: return TT_STR;
  150.         case TID_FLOW_BITS: return TT_STR;
  151.         case TID_TCP_FLG: return TT_STR;
  152.         case TID_IP_FRG: return TT_STR;
  153.         case TID_BYTE_TEST: return TT_INT;
  154.         case TID_BYTE_JUMP: return TT_INT;
  155.         case TID_SAMEADR: return TT_BOOL;
  156.  
  157.     }
  158.     return TT_INT;
  159. }
  160.  
  161. ///////////////////////////////////////////////////////////////////////
  162. // IDS_GetTokenValueTypeByTokenAttr
  163. //
  164. function IDS_GetTokenValueTypeByTokenAttr( strTokenIdAttr )
  165. {
  166.     switch (strTokenIdAttr) {
  167.         case "pcre": return TT_STR;
  168.         case "content": return TT_STR;
  169.         case "ip_frg": return TT_STR;
  170.         case "tcp_flg": return TT_STR;
  171.         case "flowbits": return TT_STR;
  172.         case "flow": return TT_STR;
  173.         case "byte_test": return TT_INT;
  174.         case "byte_jump": return TT_INT;
  175.         case "sameadr": return TT_BOOL;
  176.  
  177.     }
  178.     return TT_INT;
  179. }
  180.  
  181. ///////////////////////////////////////////////////////////////////////
  182. // IDS_AddTokenToRule - eTokenType is automatically adjusted by eTokenID => string, int, bool
  183. //    if eTokenType cannot be TT_BIN right now (Value for TT_BIN is expected as a string of hexadecimal numbers (e.g. "12FE56A3" ))
  184. //  eRelation - is optional
  185. //
  186. //    this fnc should be used for all token IDs, except: TID_CONTENT, TID_BYTE_JUMP, TID_BYTE_TEST, TID_FLOW_BITS, TID_IP_FRG, TID_TCP_FLG
  187. //
  188. function IDS_AddTokenToRule( strRuleGroup, iRuleID, eTokenID, Value, eRelation, bAvoidSavingSDB )
  189. {
  190.     try {
  191.         var group = IDS_getRuleGroupList().Get(strRuleGroup);
  192.  
  193.         var eTokenType = IDS_GetTokenValueTypeByTokenID( parseInt(eTokenID) );
  194.  
  195.         var itemEnum = new Enumerator(group.RuleList);
  196.         itemEnum.moveFirst();
  197.  
  198.         while (!itemEnum.atEnd())
  199.         {
  200.             var rule = itemEnum.item();
  201.             if (rule.SID == parseInt(iRuleID))
  202.             {
  203.                 var token = rule.TokenList.CreateToken();
  204.                 token.TokenID = parseInt(eTokenID);
  205.                 token.Type = parseInt(eTokenType);
  206.                 if (parseInt(eRelation))
  207.                     token.Relation = parseInt(eRelation);
  208.                 if (Value)
  209.                 {
  210.                     if (parseInt(eTokenType) == TT_BIN)
  211.                         token.BinHEXValue = Value;
  212.                     else
  213.                         token.Value = (parseInt(eTokenType) == TT_INT) ? parseInt(Value) : ((parseInt(eTokenType) == TT_BOOL) ? parseBoolean(Value) : Value);
  214.                 }
  215.  
  216.                 rule.TokenList.Insert( token );
  217.  
  218.                 IDS_saveChanges( bAvoidSavingSDB );
  219.                 return SUCCESS;
  220.             }
  221.             itemEnum.moveNext();
  222.         }
  223.         return ErrorHandler( ERR_IDS_RULE_DOES_NOT_EXIST, STR_IDS_RULE_DOES_NOT_EXIST );
  224.     } catch(e){
  225.         return ErrorHandler( ERR_IDS_ADDING_TOKEN_FAILED, STR_IDS_ADDING_TOKEN_FAILED );
  226.     }
  227. }
  228.  
  229. ///////////////////////////////////////////////////////////////////////
  230. // IDS_AddContentTokenToRule
  231. //
  232. // content
  233. //    type: str; can contain also characters not displayable, that are written in a c-like notation \a \b \f \n \r \t \v \" \\ \0
  234. //    and \xXX, where XX is allways two digits hexadecimal number.
  235. //    optional atributes:
  236. //        complement: int, is taken as a boolean (zero, nonzero)
  237. //        uricont: int, is taken as a boolean (zero, nonzero)
  238. //        nocase: int, is taken as a boolean (zero, nonzero)
  239. //        regex: int, is taken as a boolean (zero, nonzero)
  240. //        offset: int, allways positive integer
  241. //        depth: int, allways positive integer
  242. //        within: int, allways positive integer
  243. //        distance: int, positive or negative integer
  244.  
  245. function IDS_AddContentTokenToRule( strRuleGroup, iRuleID, strValue,
  246.     bComplement, bUriCont, bNoCase, bRegEx, iOffset, iDepth, iWithin, iDistance,
  247.     bAvoidSavingSDB )
  248. {
  249.     try {
  250.         var rule = getRuleByRuleID( strRuleGroup, iRuleID );
  251.         if (!rule)
  252.             return ErrorHandler( ERR_IDS_RULE_DOES_NOT_EXIST, STR_IDS_RULE_DOES_NOT_EXIST );
  253.  
  254.         var token = rule.TokenList.CreateToken();
  255.         token.TokenID = TID_CONTENT;
  256.         token.Type = TT_STR;
  257.         token.Value = strValue;
  258.  
  259.         token.TokenAttrAsNumber("complement") = parseBoolean(bComplement);
  260.         token.TokenAttrAsNumber("uricont") = parseBoolean(bUriCont);
  261.         token.TokenAttrAsNumber("nocase") = parseBoolean(bNoCase);
  262.         token.TokenAttrAsNumber("regex") = parseBoolean(bRegEx);
  263.         token.TokenAttrAsNumber("offset") = parseInt(iOffset);
  264.         token.TokenAttrAsNumber("depth") = parseInt(iDepth);
  265.         token.TokenAttrAsNumber("within") = parseInt(iWithin);
  266.         token.TokenAttrAsNumber("distance") = parseInt(iDistance);
  267.  
  268.         rule.TokenList.Insert( token );
  269.  
  270.         IDS_saveChanges( bAvoidSavingSDB );
  271.         return SUCCESS;
  272.  
  273.     } catch(e){
  274.         return ErrorHandler( ERR_IDS_ADDING_TOKEN_FAILED, STR_IDS_ADDING_TOKEN_FAILED );
  275.     }
  276. }
  277.  
  278. ///////////////////////////////////////////////////////////////////////
  279. // IDS_AddByteJumpTokenToRule
  280. //
  281. // byte_jump
  282. //    type: int; allways positive integer, contains data size to read
  283. //    optional atributes:
  284. //        relative: int, is taken as a boolean (zero, nonzero)
  285. //        align: int, is taken as a boolean (zero, nonzero)
  286. //        format: str, can contain strings: little, big, like-c, hex, dec + oct.
  287. //        offset: int, positive or negative integer
  288.  
  289. function IDS_AddByteJumpTokenToRule( strRuleGroup, iRuleID, iValue,
  290.     iRelative, iAlign, strFormat, iOffset,
  291.     bAvoidSavingSDB )
  292. {
  293.     try {
  294.         var rule = getRuleByRuleID( strRuleGroup, iRuleID );
  295.         if (!rule)
  296.             return ErrorHandler( ERR_IDS_RULE_DOES_NOT_EXIST, STR_IDS_RULE_DOES_NOT_EXIST );
  297.  
  298.         var token = rule.TokenList.CreateToken();
  299.         token.TokenID = TID_BYTE_JUMP;
  300.         token.Type = TT_INT;
  301.         token.Value = parseInt(iValue);
  302.  
  303.         token.TokenAttrAsNumber("relative") = parseInt(iRelative);
  304.         token.TokenAttrAsNumber("align") = parseInt(iAlign);
  305.         token.TokenAttrAsNumber("offset") = parseInt(iOffset);
  306.         token.TokenAttr("format") = strFormat;
  307.  
  308.         rule.TokenList.Insert( token );
  309.  
  310.         IDS_saveChanges( bAvoidSavingSDB );
  311.         return SUCCESS;
  312.  
  313.     } catch(e){
  314.         return ErrorHandler( ERR_IDS_ADDING_TOKEN_FAILED, STR_IDS_ADDING_TOKEN_FAILED );
  315.     }
  316. }
  317.  
  318. ///////////////////////////////////////////////////////////////////////
  319. // IDS_AddByteTestTokenToRule
  320. //
  321. // byte_test
  322. //    type: int; allways positive integer, contains value to compare
  323. //    optional atributes:
  324. //        similar to byte_jump, except align, which does not exists here, plus:
  325. //        complement: int, is taken as a boolean (zero, nonzero)
  326. //        size: int, allways positive integer
  327. //        oper: str, can contain strings: equal, less, greater, and, xor + or.
  328.  
  329. function IDS_AddByteTestTokenToRule( strRuleGroup, iRuleID, iValue,
  330.     iRelative, strFormat, iOffset, bComplement, iSize, strOper,
  331.     bAvoidSavingSDB )
  332. {
  333.     try {
  334.         var rule = getRuleByRuleID( strRuleGroup, iRuleID );
  335.         if (!rule)
  336.             return ErrorHandler( ERR_IDS_RULE_DOES_NOT_EXIST, STR_IDS_RULE_DOES_NOT_EXIST );
  337.  
  338.         var token = rule.TokenList.CreateToken();
  339.         token.TokenID = TID_BYTE_TEST;
  340.         token.Type = TT_INT;
  341.         token.Value = parseInt(iValue);
  342.  
  343.         token.TokenAttrAsNumber("relative") = parseInt(iRelative);
  344.         token.TokenAttrAsNumber("offset") = parseInt(iOffset);
  345.         token.TokenAttr("format") = strFormat;
  346.         token.TokenAttrAsNumber("complement") = parseBoolean(bComplement);
  347.         token.TokenAttrAsNumber("size") = parseInt(iSize);
  348.         token.TokenAttr("oper") = strOper;
  349.  
  350.         rule.TokenList.Insert( token );
  351.  
  352.         IDS_saveChanges( bAvoidSavingSDB );
  353.         return SUCCESS;
  354.  
  355.     } catch(e){
  356.         return ErrorHandler( ERR_IDS_ADDING_TOKEN_FAILED, STR_IDS_ADDING_TOKEN_FAILED );
  357.     }
  358. }
  359.  
  360. var FLG_NOT_SET = 0,
  361.     FLG_SET = 1,
  362.     FLG_IGNORE = 2;
  363.  
  364. var FLGS_ONLY_SELECTED_MUST_BE_SET = 0,
  365.     FLGS_ALL_SELECTED_MUST_BE_SET = 1,
  366.     FLGS_ANY_SELECTED_MUST_BE_SET = 2,
  367.     FLGS_ALL_SELECTED_MUST_NOT_BE_SET = 3;
  368.  
  369. ///////////////////////////////////////////////////////////////////////
  370. // IDS_AddTcpFlgTokenToRule
  371. //        flgXXX - can be FLG_NOT_SET, FLG_SET or FLG_IGNORE
  372. //        eFlgsLogic - can be FLGS_XXX const
  373. //
  374. // tcp_flg
  375. //    type: str; can contain characters [F] [S] [R] [P] [A] [U] [1] [2] [! | * | +] (FIN, SYN, RST, PUSH, ACK, URG,
  376. //    reserved 1, reserved 2, negation, some of the bits must be set, all bits must be set)
  377. //    optional atribute:
  378. //        mask: str; can contain characters [F] [S] [R] [P] [A] [U] [1] [2]
  379. //    note: negation character (!) is present at the beginning of the string while */+ characters at the end
  380.  
  381. function IDS_AddTcpFlgTokenToRule( strRuleGroup, iRuleID,
  382.     flgFIN, flgSYN, flgRST, flgPUSH, flgACK, flgURG, flgRes1, flgRes2, eFlgsLogic,
  383.     bAvoidSavingSDB )
  384. {
  385.     try {
  386.         var rule = getRuleByRuleID( strRuleGroup, iRuleID );
  387.         if (!rule)
  388.             return ErrorHandler( ERR_IDS_RULE_DOES_NOT_EXIST, STR_IDS_RULE_DOES_NOT_EXIST );
  389.  
  390.         var token = rule.TokenList.CreateToken();
  391.         token.TokenID = TID_TCP_FLG;
  392.         token.Type = TT_STR;
  393.  
  394.         var strValue = "";
  395.         var strMask = "";
  396.  
  397.         if (parseInt(eFlgsLogic)==FLGS_ALL_SELECTED_MUST_NOT_BE_SET)
  398.             strValue += "!";
  399.  
  400.         if (parseInt(flgFIN)==FLG_SET)
  401.             strValue += "F";
  402.         if (parseInt(flgFIN)==FLG_IGNORE)
  403.             strMask += "F";
  404.         if (parseInt(flgSYN)==FLG_SET)
  405.             strValue += "S";
  406.         if (parseInt(flgSYN)==FLG_IGNORE)
  407.             strMask += "S";
  408.         if (parseInt(flgRST)==FLG_SET)
  409.             strValue += "R";
  410.         if (parseInt(flgRST)==FLG_IGNORE)
  411.             strMask += "R";
  412.         if (parseInt(flgPUSH)==FLG_SET)
  413.             strValue += "P";
  414.         if (parseInt(flgPUSH)==FLG_IGNORE)
  415.             strMask += "P";
  416.         if (parseInt(flgACK)==FLG_SET)
  417.             strValue += "A";
  418.         if (parseInt(flgACK)==FLG_IGNORE)
  419.             strMask += "A";
  420.         if (parseInt(flgURG)==FLG_SET)
  421.             strValue += "U";
  422.         if (parseInt(flgURG)==FLG_IGNORE)
  423.             strMask += "U";
  424.         if (parseInt(flgRes1)==FLG_SET)
  425.             strValue += "1";
  426.         if (parseInt(flgRes1)==FLG_IGNORE)
  427.             strMask += "1";
  428.         if (parseInt(flgRes2)==FLG_SET)
  429.             strValue += "2";
  430.         if (parseInt(flgRes2)==FLG_IGNORE)
  431.             strMask += "2";
  432.  
  433.         if (parseInt(eFlgsLogic)==FLGS_ALL_SELECTED_MUST_BE_SET)
  434.             strValue += "+";
  435.         if (parseInt(eFlgsLogic)==FLGS_ANY_SELECTED_MUST_BE_SET)
  436.             strValue += "*";
  437.  
  438.         token.Value = strValue;
  439.         if (strMask)
  440.             token.TokenAttr("mask") = strMask;
  441.  
  442.         rule.TokenList.Insert( token );
  443.  
  444.         IDS_saveChanges( bAvoidSavingSDB );
  445.         return SUCCESS;
  446.  
  447.     } catch(e){
  448.         return ErrorHandler( ERR_IDS_ADDING_TOKEN_FAILED, STR_IDS_ADDING_TOKEN_FAILED );
  449.     }
  450. }
  451.  
  452. ///////////////////////////////////////////////////////////////////////
  453. // IDS_AddIpFrgTokenToRule
  454. //        flgXXX - can be FLG_NOT_SET or FLG_SET
  455. //        eFlgsLogic - can be FLGS_XXX const
  456. //
  457. //ip_frg
  458. //    type: str; can contain characters [M] [D] [R] [! | * | +] (more fragments bit, don't fragment bit, reserved bit,
  459. //    negation, some of the bits must be set, all bits must be set)
  460. //    note: negation character (!) is present at the beginning of the string while */+ characters at the end
  461.  
  462. function IDS_AddIpFrgTokenToRule( strRuleGroup, iRuleID,
  463.     flgMORE, flgDONT, flgRES, eFlgsLogic,
  464.     bAvoidSavingSDB )
  465. {
  466.     try {
  467.         var rule = getRuleByRuleID( strRuleGroup, iRuleID );
  468.         if (!rule)
  469.             return ErrorHandler( ERR_IDS_RULE_DOES_NOT_EXIST, STR_IDS_RULE_DOES_NOT_EXIST );
  470.  
  471.         var token = rule.TokenList.CreateToken();
  472.         token.TokenID = TID_IP_FRG;
  473.         token.Type = TT_STR;
  474.  
  475.         var strValue = "";
  476.  
  477.         if (parseInt(eFlgsLogic)==FLGS_ALL_SELECTED_MUST_NOT_BE_SET)
  478.             strValue += "!";
  479.  
  480.         if (parseInt(flgMORE)==FLG_SET)
  481.             strValue += "M";
  482.         if (parseInt(flgDONT)==FLG_SET)
  483.             strValue += "D";
  484.         if (parseInt(flgRES)==FLG_SET)
  485.             strValue += "R";
  486.  
  487.         if (parseInt(eFlgsLogic)==FLGS_ALL_SELECTED_MUST_BE_SET)
  488.             strValue += "+";
  489.         if (parseInt(eFlgsLogic)==FLGS_ANY_SELECTED_MUST_BE_SET)
  490.             strValue += "*";
  491.  
  492.         token.Value = strValue;
  493.  
  494.         rule.TokenList.Insert( token );
  495.  
  496.         IDS_saveChanges( bAvoidSavingSDB );
  497.         return SUCCESS;
  498.  
  499.     } catch(e){
  500.         return ErrorHandler( ERR_IDS_ADDING_TOKEN_FAILED, STR_IDS_ADDING_TOKEN_FAILED );
  501.     }
  502. }
  503.  
  504. ///////////////////////////////////////////////////////////////////////
  505. // IDS_AddFlowBitsTokenToRule
  506. //
  507. //flowbits
  508. //    type: str;
  509. //    attribute:
  510. //            state: str
  511.  
  512. function IDS_AddFlowBitsTokenToRule( strRuleGroup, iRuleID, strValue, strState,    bAvoidSavingSDB )
  513. {
  514.     try {
  515.         var rule = getRuleByRuleID( strRuleGroup, iRuleID );
  516.         if (!rule)
  517.             return ErrorHandler( ERR_IDS_RULE_DOES_NOT_EXIST, STR_IDS_RULE_DOES_NOT_EXIST );
  518.  
  519.         var token = rule.TokenList.CreateToken();
  520.         token.TokenID = TID_FLOW_BITS;
  521.         token.Type = TT_STR;
  522.  
  523.         token.Value = strValue;
  524.         if (strState)
  525.             token.TokenAttr("state") = strState;
  526.  
  527.         rule.TokenList.Insert( token );
  528.  
  529.         IDS_saveChanges( bAvoidSavingSDB );
  530.         return SUCCESS;
  531.  
  532.     } catch(e){
  533.         return ErrorHandler( ERR_IDS_ADDING_TOKEN_FAILED, STR_IDS_ADDING_TOKEN_FAILED );
  534.     }
  535. }
  536.  
  537.  
  538. ///////////////////////////////////////////////////////////////////////
  539. // IDS_RemoveTokenFromRule - fails if rule or token does not exist
  540. //    Value, eRelation - are optional, if one of them not supplied, then the first token match of type eTokenID is deleted
  541. //
  542. function IDS_RemoveTokenFromRule( strRuleGroup, iRuleID, eTokenID, Value, eRelation, bAvoidSavingSDB )
  543. {
  544.     try {
  545.         var group = IDS_getRuleGroupList().Get(strRuleGroup);
  546.  
  547.         var eTokenType = IDS_GetTokenValueTypeByTokenID( parseInt(eTokenID) );
  548.  
  549.         var itemEnum = new Enumerator(group.RuleList);
  550.         itemEnum.moveFirst();
  551.  
  552.         while (!itemEnum.atEnd())
  553.         {
  554.             var rule = itemEnum.item();
  555.             if (rule.SID == parseInt(iRuleID))
  556.             {
  557.                 var tokenEnum = new Enumerator(rule.TokenList);
  558.                 tokenEnum.moveFirst();
  559.  
  560.                 while (!tokenEnum.atEnd())
  561.                 {
  562.                     var token = tokenEnum.item();
  563.  
  564.                     if (token.TokenID == parseInt(eTokenID) && (eRelation ? token.Relation == parseInt(eRelation) : true)
  565.                         && (parseInt(token.Type) == TT_BIN ? (Value ? token.BinHEXValue.toUpperCase() == Value.toUpperCase() : true) : (Value ? token.Value.toString() == Value.toString() : true)) )
  566.                     {
  567.                         rule.TokenList.Remove( token );
  568.                         IDS_saveChanges( bAvoidSavingSDB );
  569.                         return SUCCESS;
  570.                     }
  571.                     tokenEnum.moveNext();
  572.                 }
  573.             }
  574.             itemEnum.moveNext();
  575.         }
  576.     } catch(e){
  577.     }
  578.  
  579.     return ErrorHandler( ERR_IDS_DELETE_TOKEN_FAILED, STR_IDS_DELETE_TOKEN_FAILED );
  580. }
  581.  
  582. /*
  583. ///////////////////////////////////////////////////////////////////////
  584. // IDS_GenerateUniqueSID - IDS parser does not support this function yet itself => this one is quite slow...
  585. //    this function is used internally by IDS_AddRule
  586. //
  587. function IDS_GenerateUniqueSID( groupList )
  588. {
  589.     try {
  590.         var sid = 0x40000001;
  591.  
  592.         while (sid < 0xC0000000)
  593.         {
  594.             var bMatchFound = false;
  595.  
  596.             var groupEnum = new Enumerator( groupList );
  597.             groupEnum.moveFirst();
  598.  
  599.             while (!groupEnum.atEnd())
  600.             {
  601.                 var group = groupEnum.item();
  602.                 var ruleList = group.RuleList;
  603.  
  604.                 var itemEnum = new Enumerator(ruleList);
  605.                 itemEnum.moveFirst();
  606.  
  607.                 while (!itemEnum.atEnd())
  608.                 {
  609.                     var rule = itemEnum.item();
  610.                     if (rule.SID == sid)
  611.                     {
  612.                         bMatchFound = true;
  613.                         break;
  614.                     }
  615.                     itemEnum.moveNext();
  616.                 }
  617.  
  618.                 if (bMatchFound)
  619.                     break;
  620.  
  621.                 groupEnum.moveNext();
  622.             }
  623.  
  624.             if (!bMatchFound)
  625.                 return sid;
  626.  
  627.             sid++;
  628.         }
  629.         return 0;
  630.     } catch(e){
  631.         return 0;
  632.     }
  633. }
  634. */
  635.  
  636. ///////////////////////////////////////////////////////////////////////
  637. // IDS_AddRule - adds new rule to existing strRuleGroup
  638. //   if iRuleSID is missing or zero, then a new unique rule ID (SID) is generated
  639. //     bIsPreventionRule - if set to nonzero, then the rule is for IPS instead of IDS
  640. //     strLocIPAddressID, strRemIPAddressID => these are only IDs of predefined IP address objects,
  641. //    cannot contain IP address directly
  642. //   strLocalPorts, strRemotePorts => syntax "*", "80", "127-129", "!1000-1999" is supported, used only if TCP/UDP
  643. //   tokens can be added only to an existing rule through a separate function
  644. //   returns SID as a string (hexa format, e.g. "0x40000001") or empty string on failure
  645. //
  646. function IDS_AddRule( strRuleGroup, strName,
  647.     eProtocol, eDirection, strLocalPorts, strRemotePorts, strLocIPAddressID, strRemIPAddressID,
  648.     bIsPreventionRule, bDisabled, iRuleID, bAvoidSavingSDB )
  649. {
  650.     try {
  651.         var groupList = IDS_getRuleGroupList();
  652.         var group = groupList.Get(strRuleGroup);
  653.         var ruleList = group.RuleList;
  654.  
  655.         var rule = ruleList.CreateRule();
  656.  
  657.         rule.Name = strName;
  658.  
  659.         // if the iRuleID is not supplied (the most common), then a unique ID is created
  660.         if (iRuleID && parseInt(iRuleID))
  661.             rule.SID = iRuleID;
  662.         else
  663.             rule.SID = IDS_generateSID(); //IDS_GenerateUniqueSID( groupList );
  664.         if (!rule.SID)
  665.         {
  666.             ErrorHandler( ERR_IDS_ADDING_RULE_FAILED, STR_IDS_ADDING_RULE_FAILED );
  667.             return "";
  668.         }
  669.  
  670.         rule.AccessResult = parseBoolean(bIsPreventionRule) ? AR_PREVENT : AR_ALLOW;
  671.         rule.AuditLevel = AL_MONITOR;
  672.         rule.Enabled = parseBoolean(bDisabled) ? false : true;
  673.  
  674.         rule.RemIPAddressID = strRemIPAddressID;
  675.         rule.LocIPAddressID = strLocIPAddressID;
  676.  
  677.         rule.Protocol = eProtocol ? parseInt(eProtocol) : 0;
  678.         rule.Direction = eDirection ? parseInt(eDirection) : 0;
  679.  
  680.         // only TCP/UDP can have ports
  681.         if (PROT_TCP == rule.Protocol || PROT_UDP == rule.Protocol || PROT_TCP_UDP == rule.Protocol || PROT_TCP_S == rule.Protocol)
  682.         {
  683.             rule.LocalPortFrom = 0;
  684.             rule.LocalPortTo = 0;
  685.             rule.RemotePortFrom = 0;
  686.             rule.RemotePortTo = 0;
  687.  
  688.             // in addition to FW module, here also negation can be present
  689.             if (strLocalPorts)
  690.             {
  691.                 if ( strLocalPorts == "*")
  692.                     rule.LocalPortTo = 65535;
  693.                 else {
  694.                     if ('!' == strLocalPorts.charAt(0))
  695.                     {
  696.                         rule.LocalPortsInverted = true;
  697.                         rule.LocalPortFrom = parseInt(strLocalPorts.substr(1));
  698.                     } else
  699.                         rule.LocalPortFrom = parseInt(strLocalPorts);
  700.  
  701.                     var Idx = strLocalPorts.search( "-" );
  702.                     if ((-1) != Idx)
  703.                         rule.LocalPortTo = parseInt( strLocalPorts.substr(Idx+1) );
  704.                     else
  705.                         rule.LocalPortTo = rule.LocalPortFrom;
  706.                 }
  707.             }
  708.             if (strRemotePorts)
  709.             {
  710.                 if ( strRemotePorts == "*")
  711.                     rule.RemotePortTo = 65535;
  712.                 else {
  713.                     if ('!' == strRemotePorts.charAt(0))
  714.                     {
  715.                         rule.RemotePortsInverted = true;
  716.                         rule.RemotePortFrom = parseInt(strRemotePorts.substr(1));
  717.                     } else
  718.                         rule.RemotePortFrom = parseInt(strRemotePorts);
  719.  
  720.                     var Idx = strRemotePorts.search( "-" );
  721.                     if ((-1) != Idx)
  722.                         rule.RemotePortTo = parseInt( strRemotePorts.substr(Idx+1) );
  723.                     else
  724.                         rule.RemotePortTo = rule.RemotePortFrom;
  725.                 }
  726.             }
  727.         }
  728.  
  729.         var iRetVal = rule.SID;
  730.  
  731.         //rule.TokenList = ;
  732.         //rule.Assignment = ;
  733.  
  734.         ruleList.Insert(rule);
  735.  
  736.         IDS_saveChanges( bAvoidSavingSDB );
  737.         return ("0x" + iRetVal.toString(16));
  738.  
  739.     } catch(e){
  740.         ErrorHandler( ERR_IDS_ADDING_RULE_FAILED, STR_IDS_ADDING_RULE_FAILED );
  741.         return "";
  742.     }
  743. }
  744.  
  745.  
  746. ///////////////////////////////////////////////////////////////////////
  747. // IDS_DeleteRule - fails if rule does not exist
  748. function IDS_DeleteRule( strRuleGroup, iRuleID, bAvoidSavingSDB )
  749. {
  750.     try {
  751.         var group = IDS_getRuleGroupList().Get(strRuleGroup);
  752.         var ruleList = group.RuleList;
  753.         //var rule = ruleList.Get(strRuleID); => not exists => must walk through the rules...
  754.         //if (rule)
  755.         //    ruleList.Remove(rule);
  756.         var itemEnum = new Enumerator(ruleList);
  757.         itemEnum.moveFirst();
  758.  
  759.         while (!itemEnum.atEnd())
  760.         {
  761.             var rule = itemEnum.item();
  762.             if (rule.SID == parseInt(iRuleID))
  763.             {
  764.                 ruleList.Remove(rule);
  765.                 IDS_saveChanges( bAvoidSavingSDB );
  766.                 return SUCCESS;
  767.             }
  768.             itemEnum.moveNext();
  769.         }
  770.  
  771.         return ErrorHandler( ERR_IDS_RULE_DOES_NOT_EXIST, STR_IDS_RULE_DOES_NOT_EXIST );
  772.  
  773.     } catch(e){
  774.         return ErrorHandler( ERR_IDS_DELETE_RULE_FAILED, STR_IDS_DELETE_RULE_FAILED );
  775.     }
  776. }
  777.  
  778.  
  779. ///////////////////////////////////////////////////////////////////////
  780. // IDS_EnableRule - enables or disables particular rule, the rule is not deleted from the database
  781. function IDS_EnableRule( strRuleGroup, iRuleID, bDisable, bAvoidSavingSDB )
  782. {
  783.     try {
  784.         var group = IDS_getRuleGroupList().Get(strRuleGroup);
  785.         var ruleList = group.RuleList;
  786.  
  787.         var itemEnum = new Enumerator(ruleList);
  788.         itemEnum.moveFirst();
  789.  
  790.         while (!itemEnum.atEnd())
  791.         {
  792.             var rule = itemEnum.item();
  793.             if (rule.SID == parseInt(iRuleID))
  794.             {
  795.                 rule.Enabled = parseBoolean(bDisable) ? false : true;
  796.                 IDS_saveChanges( bAvoidSavingSDB );
  797.                 return SUCCESS;
  798.             }
  799.             itemEnum.moveNext();
  800.         }
  801.  
  802.         return ErrorHandler( ERR_IDS_RULE_DOES_NOT_EXIST, STR_IDS_RULE_DOES_NOT_EXIST );
  803.  
  804.     } catch(e){
  805.         return ErrorHandler( ERR_IDS_EDIT_RULE_FAILED, STR_IDS_EDIT_RULE_FAILED );
  806.     }
  807. }
  808.  
  809. ///////////////////////////////////////////////////////////////////////
  810. // IDS_SetDirection -
  811. function IDS_SetDirection( strRuleGroup, iRuleID, eDirection, bAvoidSavingSDB )
  812. {
  813.     try {
  814.         var group = IDS_getRuleGroupList().Get(strRuleGroup);
  815.         var ruleList = group.RuleList;
  816.  
  817.         var itemEnum = new Enumerator(ruleList);
  818.         itemEnum.moveFirst();
  819.  
  820.         while (!itemEnum.atEnd())
  821.         {
  822.             var rule = itemEnum.item();
  823.             if (rule.SID == parseInt(iRuleID))
  824.             {
  825.                 rule.Direction = eDirection ? parseInt(eDirection) : 0;
  826.  
  827.                 IDS_saveChanges( bAvoidSavingSDB );
  828.                 return SUCCESS;
  829.             }
  830.             itemEnum.moveNext();
  831.         }
  832.  
  833.         return ErrorHandler( ERR_IDS_RULE_DOES_NOT_EXIST, STR_IDS_RULE_DOES_NOT_EXIST );
  834.  
  835.     } catch(e){
  836.         return ErrorHandler( ERR_IDS_EDIT_RULE_FAILED, STR_IDS_EDIT_RULE_FAILED );
  837.     }
  838. }
  839.  
  840. ///////////////////////////////////////////////////////////////////////
  841. // IDS_SetRemoteIP -
  842. function IDS_SetRemoteIP( strRuleGroup, iRuleID, strRemIPAddressID, bAvoidSavingSDB )
  843. {
  844.     try {
  845.         var group = IDS_getRuleGroupList().Get(strRuleGroup);
  846.         var ruleList = group.RuleList;
  847.  
  848.         var itemEnum = new Enumerator(ruleList);
  849.         itemEnum.moveFirst();
  850.  
  851.         while (!itemEnum.atEnd())
  852.         {
  853.             var rule = itemEnum.item();
  854.             if (rule.SID == parseInt(iRuleID))
  855.             {
  856.                 rule.RemIPAddressID = strRemIPAddressID;
  857.  
  858.                 IDS_saveChanges( bAvoidSavingSDB );
  859.                 return SUCCESS;
  860.             }
  861.             itemEnum.moveNext();
  862.         }
  863.  
  864.         return ErrorHandler( ERR_IDS_RULE_DOES_NOT_EXIST, STR_IDS_RULE_DOES_NOT_EXIST );
  865.  
  866.     } catch(e){
  867.         return ErrorHandler( ERR_IDS_EDIT_RULE_FAILED, STR_IDS_EDIT_RULE_FAILED );
  868.     }
  869. }
  870.  
  871. ///////////////////////////////////////////////////////////////////////
  872. // IDS_SetAccess -
  873. function IDS_SetAccess( strRuleGroup, iRuleID, bIsPreventionRule, bAvoidSavingSDB )
  874. {
  875.     try {
  876.         var group = IDS_getRuleGroupList().Get(strRuleGroup);
  877.         var ruleList = group.RuleList;
  878.  
  879.         var itemEnum = new Enumerator(ruleList);
  880.         itemEnum.moveFirst();
  881.  
  882.         while (!itemEnum.atEnd())
  883.         {
  884.             var rule = itemEnum.item();
  885.             if (rule.SID == parseInt(iRuleID))
  886.             {
  887.                 rule.AccessResult = parseBoolean(bIsPreventionRule) ? AR_PREVENT : AR_ALLOW;
  888.  
  889.                 IDS_saveChanges( bAvoidSavingSDB );
  890.                 return SUCCESS;
  891.             }
  892.             itemEnum.moveNext();
  893.         }
  894.  
  895.         return ErrorHandler( ERR_IDS_RULE_DOES_NOT_EXIST, STR_IDS_RULE_DOES_NOT_EXIST );
  896.  
  897.     } catch(e){
  898.         return ErrorHandler( ERR_IDS_EDIT_RULE_FAILED, STR_IDS_EDIT_RULE_FAILED );
  899.     }
  900. }
  901.  
  902. ///////////////////////////////////////////////////////////////////////
  903. // IDS_SetRemPort -
  904. function IDS_SetRemPort( strRuleGroup, iRuleID, strRemport, bAvoidSavingSDB )
  905. {
  906.     try {
  907.         var group = IDS_getRuleGroupList().Get(strRuleGroup);
  908.         var ruleList = group.RuleList;
  909.  
  910.         var itemEnum = new Enumerator(ruleList);
  911.         itemEnum.moveFirst();
  912.  
  913.         while (!itemEnum.atEnd())
  914.         {
  915.             var rule = itemEnum.item();
  916.             if (rule.SID == parseInt(iRuleID))
  917.             {
  918.                 rule.RemotePortFrom = 0;
  919.                 rule.RemotePortTo = 0;
  920.                 rule.RemotePortsInverted = false;
  921.  
  922.                 // in addition to FW module, here also negation can be present
  923.                 if (strRemport)
  924.                 {
  925.                     if ( strRemport == "*")
  926.                         rule.RemotePortTo = 65535;
  927.                     else {
  928.                         if ('!' == strRemport.charAt(0))
  929.                         {
  930.                             rule.RemotePortsInverted = true;
  931.                             rule.RemotePortFrom = parseInt(strRemport.substr(1));
  932.                         } else
  933.                             rule.RemotePortFrom = parseInt(strRemport);
  934.  
  935.                         var Idx = strRemport.search( "-" );
  936.                         if ((-1) != Idx)
  937.                             rule.RemotePortTo = parseInt( strRemport.substr(Idx+1) );
  938.                         else
  939.                             rule.RemotePortTo = rule.RemotePortFrom;
  940.                     }
  941.                 }
  942.  
  943.                 IDS_saveChanges( bAvoidSavingSDB );
  944.                 return SUCCESS;
  945.             }
  946.             itemEnum.moveNext();
  947.         }
  948.  
  949.         return ErrorHandler( ERR_IDS_RULE_DOES_NOT_EXIST, STR_IDS_RULE_DOES_NOT_EXIST );
  950.  
  951.     } catch(e){
  952.         return ErrorHandler( ERR_IDS_EDIT_RULE_FAILED, STR_IDS_EDIT_RULE_FAILED );
  953.     }
  954. }
  955.  
  956. ///////////////////////////////////////////////////////////////////////
  957. // IDS_SetLocPort -
  958. function IDS_SetLocPort( strRuleGroup, iRuleID, strLocalPorts, bAvoidSavingSDB )
  959. {
  960.     try {
  961.         var group = IDS_getRuleGroupList().Get(strRuleGroup);
  962.         var ruleList = group.RuleList;
  963.  
  964.         var itemEnum = new Enumerator(ruleList);
  965.         itemEnum.moveFirst();
  966.  
  967.         while (!itemEnum.atEnd())
  968.         {
  969.             var rule = itemEnum.item();
  970.             if (rule.SID == parseInt(iRuleID))
  971.             {
  972.                 rule.LocalPortFrom = 0;
  973.                 rule.LocalPortTo = 0;
  974.                 rule.LocalPortsInverted = false;
  975.  
  976.                 // in addition to FW module, here also negation can be present
  977.                 if (strLocalPorts)
  978.                 {
  979.                     if ( strLocalPorts == "*")
  980.                         rule.LocalPortTo = 65535;
  981.                     else {
  982.                         if ('!' == strLocalPorts.charAt(0))
  983.                         {
  984.                             rule.LocalPortsInverted = true;
  985.                             rule.LocalPortFrom = parseInt(strLocalPorts.substr(1));
  986.                         } else
  987.                             rule.LocalPortFrom = parseInt(strLocalPorts);
  988.  
  989.                         var Idx = strLocalPorts.search( "-" );
  990.                         if ((-1) != Idx)
  991.                             rule.LocalPortTo = parseInt( strLocalPorts.substr(Idx+1) );
  992.                         else
  993.                             rule.LocalPortTo = rule.LocalPortFrom;
  994.                     }
  995.                 }
  996.  
  997.                 IDS_saveChanges( bAvoidSavingSDB );
  998.                 return SUCCESS;
  999.             }
  1000.             itemEnum.moveNext();
  1001.         }
  1002.  
  1003.         return ErrorHandler( ERR_IDS_RULE_DOES_NOT_EXIST, STR_IDS_RULE_DOES_NOT_EXIST );
  1004.  
  1005.     } catch(e){
  1006.         return ErrorHandler( ERR_IDS_EDIT_RULE_FAILED, STR_IDS_EDIT_RULE_FAILED );
  1007.     }
  1008. }
  1009.  
  1010. // the following functions are exactly the same as their FW_ equivalents
  1011. //  => IDS_AddPredefinedIPAddressObject, IDS_DeletePredefinedIPAddressObject, IDS_AddIPAddressToPredefinedObject
  1012. //     IDS_ClearAllIPAddressesFromPredefinedObject, IDS_RemoveIPAddressFromPredefinedObject
  1013.  
  1014. ///////////////////////////////////////////////////////////////////////
  1015. // IDS_AddPredefinedIPAddressObject
  1016. function IDS_AddPredefinedIPAddressObject( strIPAddressObjectID, strIPAddress, bAvoidSavingSDB )
  1017. {
  1018.     try {
  1019.         var definitionList = IDS_getDefinitionList();
  1020.         var definition = definitionList.CreateDefinition();
  1021.  
  1022.         definition.DefinitionID = strIPAddressObjectID;
  1023.         definition.ObjectType = OT_IDS_IPADDR;
  1024.  
  1025.         if (strIPAddress)
  1026.         {
  1027.             var newItem = definition.ItemList.CreateItem();
  1028.             newItem.Content = strIPAddress;
  1029.             definition.ItemList.Insert(newItem);
  1030.         }
  1031.  
  1032.         definitionList.Insert( definition );
  1033.  
  1034.         IDS_saveChanges( bAvoidSavingSDB );
  1035.         return SUCCESS;
  1036.     }
  1037.     catch(e) {
  1038.         return ErrorHandler( ERR_IDS_ADDING_OBJECT_FAILED, STR_IDS_ADDING_OBJECT_FAILED );
  1039.     }
  1040. }
  1041.  
  1042. ///////////////////////////////////////////////////////////////////////
  1043. // IDS_DeletePredefinedIPAddressObject
  1044. function IDS_DeletePredefinedIPAddressObject( strIPAddressObjectID, bAvoidSavingSDB )
  1045. {
  1046.     // remove it from FW database
  1047.     try {
  1048.         var definitionList = IDS_getDefinitionList();
  1049.  
  1050.         var definition = definitionList.Get( strIPAddressObjectID );
  1051.         if (definition)
  1052.             definitionList.Remove(definition);
  1053.  
  1054.         IDS_saveChanges( bAvoidSavingSDB );
  1055.         return SUCCESS;
  1056.     }
  1057.     catch(e) {
  1058.         return ErrorHandler( ERR_IDS_DELETE_OBJECT_FAILED, STR_IDS_DELETE_OBJECT_FAILED );
  1059.     }
  1060. }
  1061.  
  1062. ///////////////////////////////////////////////////////////////////////
  1063. // IDS_AddIPAddressToPredefinedObject - in addition to FW, also 'complement' keyword can be present
  1064. function IDS_AddIPAddressToPredefinedObject( strIPAddressObjectID, strIPAddress, bAvoidSavingSDB )
  1065. {
  1066.     try {
  1067.         var definitionList = IDS_getDefinitionList();
  1068.         var definition = definitionList.Get( strIPAddressObjectID );
  1069.         var newItem = definition.ItemList.CreateItem();
  1070.         newItem.Content = strIPAddress;
  1071.         definition.ItemList.Insert(newItem);
  1072.  
  1073.         IDS_saveChanges( bAvoidSavingSDB );
  1074.         return SUCCESS;
  1075.     }
  1076.     catch(e) {
  1077.         return ErrorHandler( ERR_IDS_EDIT_OBJECT_FAILED, STR_IDS_EDIT_OBJECT_FAILED );
  1078.     }
  1079. }
  1080.  
  1081. ///////////////////////////////////////////////////////////////////////
  1082. // IDS_ClearAllIPAddressesFromPredefinedObject
  1083. function IDS_ClearAllIPAddressesFromPredefinedObject( strIPAddressObjectID, bAvoidSavingSDB )
  1084. {
  1085.     try {
  1086.         var definitionList = IDS_getDefinitionList();
  1087.         var definition = definitionList.Get( strIPAddressObjectID );
  1088.  
  1089.         definition.ItemList.Clear();
  1090.  
  1091.         IDS_saveChanges( bAvoidSavingSDB );
  1092.         return SUCCESS;
  1093.     }
  1094.     catch(e) {
  1095.         return ErrorHandler( ERR_IDS_EDIT_OBJECT_FAILED, STR_IDS_EDIT_OBJECT_FAILED );
  1096.     }
  1097. }
  1098.  
  1099.  
  1100. ///////////////////////////////////////////////////////////////////////
  1101. // IDS_RemoveIPAddressFromPredefinedObject
  1102. function IDS_RemoveIPAddressFromPredefinedObject( strIPAddressObjectID, strIPAddress, bAvoidSavingSDB )
  1103. {
  1104.     try {
  1105.         var definitionList = IDS_getDefinitionList();
  1106.         var definition = definitionList.Get( strIPAddressObjectID );
  1107.  
  1108.         var itemEnum = new Enumerator(definition.ItemList);
  1109.         itemEnum.moveFirst();
  1110.  
  1111.         while (!itemEnum.atEnd())
  1112.         {
  1113.             var item = itemEnum.item();
  1114.             if (item.Content == strIPAddress)
  1115.             {
  1116.                 definition.ItemList.Remove(item);
  1117.                 break;
  1118.             }
  1119.             itemEnum.moveNext();
  1120.         }
  1121.  
  1122.         IDS_saveChanges( bAvoidSavingSDB );
  1123.         return SUCCESS;
  1124.     }
  1125.     catch(e) {
  1126.         return ErrorHandler( ERR_IDS_EDIT_OBJECT_FAILED, STR_IDS_EDIT_OBJECT_FAILED );
  1127.     }
  1128. }
  1129.  
  1130.